home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Sample Code / System 7.0 Samples / AEObject-Edition1.0.2 Sample / Utilities.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-18  |  18.4 KB  |  529 lines  |  [TEXT/MPS ]
  1. /*------------------------------------------------------------------------------
  2. *
  3. *  Apple Developer Technical Support
  4. *
  5. *  
  6. *
  7. *  Program: AEObject-Edition Sample
  8. *  File:   Utilities.c -C Source
  9. *
  10. *  by: C.K. Haun <TR>
  11. *
  12. *  Copyright © 1990-1992 Apple Computer, Inc.
  13. *  All rights reserved.
  14. *
  15. *------------------------------------------------------------------------------
  16. * This file contains some of our window handling routines.  I created it 
  17. * primarily to take some of the clutter out of the main.c file.
  18. * It also contains the clipboard handlers
  19. *----------------------------------------------------------------------------*/
  20.  
  21. #define __GUTILS__
  22.  
  23. #include "Sampdefines.h"
  24.  
  25. #pragma segment Utils
  26.  
  27. /* standardDialogFilter is _new_ and dispatches to the System 7 */
  28. /* standard dialog filter.  Please see tech note #304 */
  29. /* for details on how this works, and why  I am checking  */
  30. /* for update events in this thing */
  31. /* Look right below for one for Alerts */
  32. pascal Boolean standardDialogFilter(DialogPtr theDialog, EventRecord *theEvent, short *itemHit)
  33. {
  34.     if (theEvent->what == updateEvt && theEvent->message != theDialog ){
  35.         WindowPtr theWindow = (WindowPtr)theEvent->message;
  36.         /* draw my window if it's really mine */
  37.         if(IsMyWindow(theWindow)){
  38.             DrawIt((WindowPtr)theWindow);     
  39.             *itemHit = 0;
  40.             return(false);    /* tell the dialog manager I handled this event */
  41.         }
  42.     } else {
  43.         ModalFilterUPP stdProc;
  44.         GetStdFilterProc(&stdProc);
  45.         return CallModalFilterProc(stdProc, theDialog, theEvent, itemHit);
  46.     }
  47. } /* end  standardDialogFilter */
  48.  
  49. pascal Boolean standardAlertFilter(DialogPtr theDialog, EventRecord *theEvent, short *itemHit)
  50. {
  51.     Boolean returnVal = false;    
  52.     if(theEvent->what == updateEvt && theEvent->message != theDialog ){
  53.     WindowPtr theWindow = (WindowPtr)theEvent->message;
  54.     /* draw my window if it's really mine */
  55.     if(IsMyWindow(theWindow)){
  56.     DrawIt((WindowPtr)theWindow);     
  57.     *itemHit = 0;
  58.     returnVal = false;
  59.     }
  60.     } else {
  61.     /* for alerts we have to check for keys ourselves, since we didn't have a chance to */
  62.     /* call SetDialogCancel or anything */
  63.     
  64.         if ((theEvent->what == keyDown) || (theEvent->what == autoKey)) {
  65.     short tempItem; Handle tempHandle;
  66.     Rect tempRect;
  67.         char theKey = theEvent->message & charCodeMask;
  68.         switch (theKey) {
  69.         long tilticks;
  70.             case kReturnKey:
  71.             case kEnterKey:                                 /* enter key */
  72.                 /* This filters for Return or Enter as item 1, and Esc as item 2 */
  73.                 *itemHit = 1;                         /* change whatever the current item is to the OK item */
  74.                 /* now we need to invert the button */
  75.                 GetDialogItem(theDialog, 1, &tempItem, &tempHandle, &tempRect);
  76.                 if(tempItem == ctrlItem){
  77.                 /* double check for the unlikely event that this is _not_ a button */
  78.                 HiliteControl(SnatchHandle(theDialog, ok), inButton);
  79.                 Delay(8, &tilticks);                        /* wait about 8 ticks so they can see it */
  80.                 HiliteControl(SnatchHandle(theDialog, ok), false);
  81.               
  82.                 returnVal = true;
  83.                 }
  84.                 break;
  85.                 /* This filters the escape key as the same as item 2 (the canx button, usually ) */
  86.             case kEscKey:
  87.                 *itemHit = 2;
  88.                 if(tempItem == ctrlItem){
  89.                 /* much more likely that this may not be a button */
  90.  
  91.                 HiliteControl(SnatchHandle(theDialog, cancel), inButton);
  92.                 Delay(8, &tilticks);                        /* wait about 8 ticks so they can see it */
  93.                 HiliteControl(SnatchHandle(theDialog, cancel), false);
  94.                 returnVal = true;
  95.                 }
  96.                 break;
  97.             }
  98.        
  99.     }
  100.     
  101.     
  102.     
  103.     
  104.     
  105.     
  106.     
  107.     
  108.     
  109.     }
  110. return(returnVal);    
  111. } /* end  standardDialogFilter */
  112.  
  113. /* Gets the ControlHandle for the item you want in the dialog box thebox.  */
  114. /* Handy for setting checkboxes and radio buttons */
  115. ControlHandle SnatchHandle(DialogPtr thebox, short theGetItem)
  116. {
  117.     short itemtype;
  118.     Rect itemrect;
  119.     Handle thandle;    
  120.     GetDialogItem(thebox, theGetItem, &itemtype, &thandle, &itemrect);
  121.     return((ControlHandle)thandle);
  122. } /* end SnatchHandle */
  123.  
  124. /* MakeRect converts two points into a rect. */
  125. /* it also insures that the rect is not reversed */
  126. void MakeRect(Point *aPoint, Point *bPoint, Rect *putRect)
  127. {
  128.     short temp;
  129.     putRect->top = aPoint->v;
  130.     putRect->left = aPoint->h;
  131.     putRect->bottom = bPoint->v;
  132.     putRect->right = bPoint->h;
  133.     if (putRect->top > putRect->bottom) {
  134.         temp = putRect->bottom;
  135.         putRect->bottom = putRect->top;
  136.         putRect->top = temp;
  137.     }
  138.     if (putRect->left > putRect->right) {
  139.         temp = putRect->right;
  140.         putRect->right = putRect->left;
  141.         putRect->left = temp;
  142.     }
  143.     if (putRect->right == putRect->left)
  144.         putRect->left++;
  145.     if (putRect->bottom == putRect->top)
  146.         putRect->bottom++;
  147. } /* end MakeRect */
  148.  
  149.  
  150. /* ties two P strings together.  Haven't we all written this at one time or another???? */
  151. void AppendString(Str255 target, Str255 appendIt)
  152. {
  153.     BlockMove((Ptr)(appendIt + 1), (Ptr)(target + (target[0])+1), appendIt[0]);
  154.     target[0] += appendIt[0];
  155. } /* end AppendString */
  156.  
  157. /* PureCursor checks to see if the last keystroke was a 'pure' cursor */
  158. /* moving keystroke.  This is important for setting Undo for text typing, */
  159. /* if I had put that in */
  160. Boolean PureCursor(char theKey)
  161. {
  162.     register qq;
  163.     char curChars[4] =  {
  164.         kLeftArrow, kRightArrow, kUpArrow, kDownArrow
  165.     };
  166.     Boolean result = false;
  167.     for (qq = 0; qq < 4; qq++) {
  168.         if (theKey == curChars[qq])
  169.             result = true;
  170.     }
  171.     return(result);
  172.     
  173. } /* end PureCursor */
  174.  
  175. /* This tries as hard as it can to resize a  handle, avoiding the problem SetHandleSize */
  176. /* has when a block is surrounded by locked stuff.  */
  177. /* Of course if you use this, you can only have one copy of the handle around and you */
  178. /* always must reference that handle, since the master pointer contained within it */
  179. /* can change during the ReallocateHandle call.  But you should be doing that anyway (nag nag nag) */
  180. OSErr MySetHandleSize(Handle theHandle, Size theSize)
  181. {
  182.     OSErr memErr;
  183.     Handle tempHand = theHandle;
  184.     SetHandleSize(theHandle, theSize);
  185.     memErr = MemError();
  186.     if (!memErr)
  187.         return(noErr);
  188.     /* could not resize the handle.  Why? */
  189.     if (memErr != memFullErr)
  190.         return(memErr);                                     /* not something we can deal with */
  191.     /* either the memory is really not available, or there is a locked pointer
  192.     *   above the handle we're resizing.  We'll try seeing if the memory 
  193.     *   is actually there first. */
  194.     ShowMe("\p mem err", memErr, __LINE__);
  195.     if (!(CompactMem(theSize) >= theSize))
  196.         return(MemError());                                 /* memory really is full, bail */
  197.     /* OK, memory is available somewhere.  Find it */
  198.     HandToHand(&tempHand);                                  /* copy the handle */
  199.     ReallocateHandle(theHandle, theSize);                      /* resize by reallocation */
  200.     HLock(tempHand);
  201.     HLock(theHandle);
  202.     BlockMove(*tempHand, *theHandle, GetHandleSize(theHandle));     /* only move the size of the target */
  203.     HUnlock(theHandle);
  204.     DisposeHandle(tempHand);
  205. } /* end MySetHandleSize */
  206.  
  207. /* ShowMe is just a handy place to display a string and a number. */
  208. /* ••• NOTE: That I'm calling AEInteractWithUser here, instead */
  209. /* of just blasting up an alert */
  210. void ShowMe(Str255 in, OSErr aevtErr, short lineNo)
  211. {
  212.     NMRec myNotification;
  213.     Str255 nmWords;
  214.     Str32 theGuy;
  215.     Str32 theLine;
  216.     OSErr myErr;
  217.     myNotification.qType =nmType ;
  218.     myNotification.nmMark = nil;
  219.     myNotification.nmIcon = nil;
  220.     myNotification.nmSound = (Handle)-1;
  221.     myNotification.nmStr =&nmWords ;
  222.     myNotification.nmResp =nil ;
  223.  
  224.     GetIndString(&nmWords,kGeneralStrings,kErrorToSay);
  225.     myErr = AEInteractWithUser(kAEDefaultTimeout, &myNotification, gCommonIdleFunctionUPP);
  226.     if(myErr != errAENoUserInteraction ) {
  227.         ModalFilterUPP upp = NewModalFilterProc(standardAlertFilter);
  228.         InitCursor();
  229.         NumToString((long)aevtErr, theGuy);
  230.         NumToString((long)lineNo, theLine);
  231.         ParamText(in, theGuy, theLine, "");
  232.         Alert(129, upp);
  233.         DisposeRoutineDescriptor(upp);
  234.     
  235.     }
  236. } /* end ShowMe */
  237.  
  238. /* DoDiskEvents just checks the error code from the disk mount, */
  239. /* and puts up the 'Format' dialog (through DIBadMount) if need be */
  240. /* You can do much more here if you care about what disks are */
  241. /* in the drive */
  242. void DoDiskEvents(long dinfo)                               /* hi word is error code, lo word is drive number */
  243. {
  244.     short hival, loval, tommy;
  245.     Point fredpoint =  {
  246.         40, 40
  247.     };
  248.     hival = HiWord(dinfo);
  249.     loval = LoWord(dinfo);
  250.     if (hival != noErr)                                     /* something happened */ {
  251.         tommy = DIBadMount(fredpoint, dinfo);
  252.     }
  253. } /* end DoDiskEvents */
  254.  
  255. /* CommonDStart is here just because I'm tired of typing GetNewDialog and  */
  256. /* typing the d*mned (WindowPtr)-1 all the time. */
  257. /* It also sets up our default and cancel items, as expalined in TN #304 */
  258. DialogPtr CommonDStart(short DNumber, short set1, short set2)
  259. {
  260.     
  261.     DialogPtr tdial = GetNewDialog(DNumber, nil, (WindowPtr)-1);
  262.     if (set1)
  263.         SetControlValue(SnatchHandle(tdial, set1), true);
  264.     if (set2)
  265.         SetControlValue(SnatchHandle(tdial, set2), true);
  266.     SetDialogDefaultItem(tdial, ok);
  267.     SetDialogCancelItem(tdial, cancel);
  268.     
  269.     return(tdial);
  270. } /* end CommonDStart */
  271.  
  272. /* PullRect either drags a rect around the screen (for subscribers) or pulls a rect */
  273. /* rubber-band wise for anything else. I'm not using DragGryRgn because I have to check some */
  274. /* intersections along the way */
  275. /* And since an Oval has the same calling conventions as a Rect, it calls this too */
  276. void PullRect(windowCHandle theWind, Rect *startRect, Boolean isOval, Boolean useRect, Boolean onlyCorner)
  277. {
  278.     
  279.     WindowPtr theWindow = FrontWindow();
  280.     Rect oldRect;
  281.     Point endPoint, thePoint;
  282.     Boolean hreversed = false;
  283.     Boolean vreversed = false;
  284.     /* set up */
  285.     if (useRect) {
  286.         oldRect = *startRect;
  287.     } else {
  288.         oldRect.top = startRect->top = oldRect.bottom = startRect->bottom = gERecord.where.v;
  289.         oldRect.right = startRect->right = oldRect.left = startRect->left = gERecord.where.h;
  290.     }
  291.     PenMode(srcXor);                                        /* So we can rubberband */
  292.     /* see if we're dragging the whole rect, or just pulling a corner out */
  293.     if (onlyCorner) {
  294.         while (StillDown()) {                               /* Keep doing this as long as the */
  295.             /* user keeps the mouse down */            
  296.             GetMouse(&endPoint);                            /* Current mouse position in local */            
  297.             if (hreversed) {
  298.                 /* see if it flipped first */
  299.                 if (endPoint.h > startRect->right) {
  300.                     /* they flipped back */
  301.                     hreversed = false;                      /* and ignore this move */
  302.                 } else {
  303.                     /* still reversed */
  304.                     startRect->left = endPoint.h;
  305.                 }
  306.             } else {
  307.                 if (endPoint.h < startRect->left) {
  308.                     hreversed = true;
  309.                 } else {
  310.                     startRect->right = endPoint.h;
  311.                 }
  312.             }
  313.             if (vreversed) {
  314.                 /* see if it flipped first */
  315.                 if (endPoint.v > startRect->bottom) {
  316.                     /* they flipped back */
  317.                     vreversed = false;                      /* and ignore this move */
  318.                 } else {
  319.                     /* still reversed */
  320.                     startRect->top = endPoint.v;
  321.                 }
  322.             } else {
  323.                 if (endPoint.v < startRect->top) {
  324.                     vreversed = true;
  325.                 } else {
  326.                     startRect->bottom = endPoint.v;
  327.                 }
  328.             }
  329.             
  330.             /* make sure we're not intersecting a text box */
  331.             if (!InTextBox(theWind, startRect)) {
  332.                 if (*startRect != oldRect) {                /* redraw the rect only if the mouse moved  */
  333.                     if (isOval) {
  334.                         FrameOval(&oldRect);
  335.                         FrameOval(startRect);
  336.                     } else {
  337.                         FrameRect(&oldRect);
  338.                         FrameRect(startRect);               /* draw the new rect */
  339.                     }
  340.                     oldRect = *startRect;
  341.                 }
  342.             } else {
  343.                 *startRect = oldRect;
  344.             }
  345.         }
  346.     } else {
  347.     /* We're dragging the whole rectangle here */
  348.         GetMouse(&thePoint);
  349.         while (StillDown()) {                               /* keep doing it until they release the mouse */
  350.             
  351.             PenMode(patXor);
  352.             if (!EqualRect(startRect, &oldRect)) {
  353.                 FrameRect(startRect);                       /* nasty way to put up a flashing border for the drag */
  354.                 FrameRect(startRect);
  355.                 
  356.             }
  357.             GetMouse(&endPoint);
  358.             /* keep inside the window please, don't let them drag the */
  359.             /* rectangle outside the window bounds */
  360.             if ((PtInRect(endPoint, &(FrontWindow()->portRect)))) {
  361.                 if (endPoint != thePoint) {
  362.                     oldRect = *startRect;
  363.                     OffsetRect(startRect, endPoint.h - thePoint.h, endPoint.v - thePoint.v);
  364.                     if (!InTextBox(theWind, startRect)) {
  365.                         thePoint = endPoint;
  366.                     } else {
  367.                         *startRect = oldRect;
  368.                         FrameRect(startRect);               /* nasty way to put up a flashing border for the drag */
  369.                         FrameRect(startRect);
  370.                     }
  371.                 }
  372.             }
  373.         }
  374.         PenMode(normal);
  375.         
  376.     }
  377.     PenMode(srcCopy);
  378. } /* end PullRect */
  379.  
  380. /* DoAnts draws the marque box for the current selection.   */
  381. /* Please note:  No one else in the known universe does marching ants */
  382. /* like this but me.  I happen to like this   */
  383. void DoAnts(Rect *theRect)
  384. {
  385.     static short nowPat = 0;
  386.     static long timeToMarch = 0;
  387.     WindowPtr theWind = FrontWindow();
  388.     Pattern thePat;
  389.     if(TickCount() > timeToMarch || timeToMarch == 0){
  390.     if (theWind) {
  391.         windowCHandle tempWC = (windowCHandle)GetWRefCon(theWind);
  392.         if ((*tempWC)->hasSelection || theRect) {
  393.             GetIndPattern(&thePat, 128, nowPat);
  394.             nowPat++;
  395.             if (nowPat == 8)
  396.                 nowPat = 0;
  397.             PenMode(patXor);
  398.             PenPat(&thePat);
  399.             if (theRect)
  400.                 FrameRect(theRect);
  401.             else
  402.                 FrameRect(&(*tempWC)->selectionRect);
  403.             PenMode(normal);
  404.             PenPat(&qd.black);
  405.         }
  406.     }
  407.     timeToMarch = TickCount() + kMarchTime;
  408. }
  409.  
  410.  
  411. } /* end DoAnts */
  412.  
  413. /*  AdjustCursor change the cursor's shape, depending on its position. This also calculates
  414. the region where the current cursor resides (for WaitNextEvent). If the
  415. mouse is ever outside of that region, an event would be generated, causing
  416. this routine to be called, allowing us to change the region to the region
  417. the mouse is currently in.
  418. */
  419.  
  420. void AdjustCursor(Point mouse, RgnHandle region)
  421. {
  422.     WindowPtr window;
  423.     RgnHandle specialRgn;
  424.     RgnHandle tbRgn;
  425.     Rect textRect;
  426.     Rect globalPortRect;
  427.     windowCHandle shortName;
  428.     window = FrontWindow();                                 /* we only adjust the cursor when we are in front */
  429.     if (!window){
  430.         SetEmptyRgn(region);
  431.         return;                                             /* ignore also if we have no open doc windows */
  432.     }
  433.     if (((WindowPeek)window)->windowKind == kClipboardWindow || ((WindowPeek)window)->windowKind == kAEStatusWindow) {
  434.         InitCursor();
  435.         SetEmptyRgn(region);  /* don't care if a doc window not frontmost */
  436.         return;
  437.     }
  438.     if ((!gInBackground) && (IsMyWindow(window))) {
  439.         specialRgn = NewRgn();
  440.         shortName = (windowCHandle)GetWRefCon(window);
  441.         /* calculate specialRgn */
  442.         globalPortRect = window->portRect;
  443.         LocalToGlobal((Point *)&globalPortRect);
  444.         LocalToGlobal((Point *)&globalPortRect.bottom);
  445.         RectRgn(specialRgn, &globalPortRect);
  446.             if((*shortName)->boxHandle){
  447.             textRect = (*shortName)->textBox;
  448.                     LocalToGlobal((Point *)&textRect);
  449.         LocalToGlobal((Point *)&textRect.bottom);
  450.         tbRgn = NewRgn();
  451.         OpenRgn();
  452.         FrameRect(&textRect);
  453.         CloseRgn(tbRgn);
  454.         DiffRgn(specialRgn,tbRgn,specialRgn);
  455.         DisposeRgn(tbRgn);
  456.         
  457.         
  458.  
  459. }
  460.         /* change the cursor and the region parameter */
  461.         
  462.         if (PtInRect(mouse, &globalPortRect)) {
  463.             short temp;
  464.             
  465.             temp = actsToIDs[(*shortName)->currentAction];
  466.             SetMyCursor(temp);
  467.             /* if textbox then poke hole for text box */
  468.             if((*shortName)->boxHandle){
  469.             textRect = (*shortName)->textBox;
  470.         LocalToGlobal((Point *)&textRect);
  471.         LocalToGlobal((Point *)&textRect.bottom);
  472.             if(PtInRect(mouse, &textRect)){
  473.             InitCursor();
  474.             RectRgn(specialRgn, &textRect);
  475.             }
  476.             }
  477.             CopyRgn(specialRgn, region);
  478.         } else {                                            /* outside */
  479.             
  480.             InitCursor();
  481.             /* make a region that's everything _but_ our windows vis region */
  482.             /* Uhhh, I was asking for the gray region here, but that doesn't */
  483.             /* include the menu bar, so you really do need to go full open */
  484.             SetRectRgn(region, kExtremeNeg, kExtremeNeg,
  485.                                   kExtremePos, kExtremePos);
  486.             DiffRgn(region, specialRgn, region);
  487.         }
  488.         /* get rid of our local regions */
  489.         DisposeRgn(specialRgn);
  490.     }
  491. }
  492.  
  493. /* end AdjustCursor*/
  494.  
  495. Boolean CompareFSSpecs(FSSpecPtr spec1,FSSpecPtr spec2)
  496. {
  497.     Boolean returnVal = false;
  498.     
  499.     if((spec1->vRefNum == spec2->vRefNum) && (spec1->parID == spec2->parID) && (EqualString(&spec1->name,&spec2->name,false,false)))
  500.         returnVal = true;
  501.     return(returnVal);
  502. }
  503.  
  504. void SpinCursor(void)
  505. {
  506.     static short cID = kBaseMadFred;
  507.     SetCursor(*GetCursor(cID));
  508.     cID++;
  509.     if(cID > 137)cID = kBaseMadFred;
  510. }
  511.  
  512. Boolean IsMyWindow(WindowPtr theWind)
  513. {
  514.     return((((WindowPeek)theWind)->windowKind == kAEStatusWindow) || (((WindowPeek)theWind)->windowKind == kClipboardWindow) || (((WindowPeek)theWind)->windowKind == kDocumentWindow));
  515. }
  516.  
  517. Boolean IsModalFront(void)
  518. {
  519.     Boolean retVal = false;
  520.     WindowPtr theWindow = FrontWindow();
  521.     #define peekit ((WindowPeek)theWindow)->windowKind
  522.     if(peekit == plainDBox || peekit == altDBoxProc || peekit == movableDBoxProc)
  523.         retVal = true;
  524.     #undef peekit
  525.     return(retVal);    
  526. }
  527.  
  528. #undef __GUTILS__
  529.